Date: Tue, 10 Dec 1996 22:41:58 GMT
Server: NCSA/1.4.2
Content-type: text/html
Last-modified: Sat, 02 Nov 1996 19:51:27 GMT
Content-length: 24614

<html>
<head> <title> Runtime Code Generation (RTCG) </title> </head>
<body>

<h1>Runtime Code Generation (RTCG)</h1>

<h2>Terms</h2>

<em>Runtime Code Generation</em> (RTCG) is a general name
for structured techniques that change a program's instruction space
while the program is running.
There are a variety of other common, overlapping names,
such as ``dynamic compilation'' and ``self-modifying code'';
there are also a variety of other less-polite names.<p>

<blockquote>
	<em>``Friends don't let friends use SMC''</em> -- email .signature
</blockquote>

The term "demand-driven compilation" is narrower than RTCG.
It typically means that some or all parts of the language translation
process are performed on a unit of code when that unit is invoked.
Demand-driven compilation may be contrasted with runtime code
generation that is performed speculatively; with demand-driven dynamic
linking in which the address space is modified without "compilation";
and self-modifying code in which a code unit is updated by itself
which, necessarily, is after the unit has been invoked.

The term <em>dynamic compilation</em> is also narrower,
typically encompassing code that is generated dynamically
but which does not self-modify.
Dynamic compilation is most often applied to systems using
general-purpose in-core code generators
and performing code generation over sophisticated inputs
(e.g., expressions, rather than simple values)
or over dynamically-loaded source code or pseudocode.
(Beware that the term ``dynamic compilation'' is nowadays often(?)
used also to mean ``a compilation of literary works which is done on
an ongoing and/or incremental basis'',
e.g. <!WA0><!WA0><!WA0><!WA0><a href="http://www.thomson.com/tcom/resource.html">here</a>.)<p>

<em>Dynamic linking</em> adds code to the instruction space of the
program.
The code is typically generated using a code generator that is outside
of the program.
The ``new code'' may have been generated on demand for the
application;
dynamically-linked code is also used to implement
language-independent enhancement and extension, to elilminate
machine-dependencies from binaries, and to reduce the size of
binaries.
(Unfortunately, the term is also sometimes used to describe
``building hypermedia connections on an ongoing or incremental
basis''.)<p>

The term <em>runtime compilation</em> is often used to describe
loop parallelization that is done at runtime
and which performs no code generation.
The idea of runtime compilation
is that loop-carried data dependencies for,
e.g., ``<tt>x[i] = y[i+2] + z[i-5]</tt>''
can be discovered by a static compiler,
but that,
e.g., ``<tt>x[a[i]] = y[a[i+2]] + z[a[i-5]]</tt>''
cannot.
The system thus examines the values of <tt>a</tt> at runtime,
and performs parallelization at runtime, based on the values.
The system thus ``compiles'' information at runtime but
performs no code generation.
<!WA1><!WA1><!WA1><!WA1><a href="mailto:shuntak@cs.washington.edu">Write</a>
to Shun-Tak Leung (<tt>shuntak@cs.washington.edu</tt>)
for more information.<p>

<em>Instruction-Space Modification</em> is a general term,
including any topic that changes bits in an instruction space,
whether the change comes from inside the application or from
outside.<p>

<em>Just-In-Time Comiplation</em> (JIT) is the general idea that some
steps of compilation may be deferred until the code is invoked.
At the moment (1996)
most systems that use "JIT" by name are systems
that use dynamic compilation to get good performance from a portable
(machine and/or OS-independent) program representation.
Typically, the unit of translation is a loadable unit, or smaller;
for example, modules, procedures, statements, etc.,
and the input is some virtual machine byte code
rather than source text, trees, etc.
JIT is used to refer to code generation at dynamic link time as well
as invocation time.
In contrast, many other systems perform compilation "just in time"
but with the goal of fine-tuning machine-dependent code, etc.
A more preceise (but longer) name for "classical" JIT is probably
something like:
"demand-driven specialization to processor architecture
at the [module|procedure|...] level".
<p>

The term <em>self-modifying code</em> or <em>SMC</em> also refers to RTCG
but it is harder to pin down because
there are many interpretations of ``modify''
and so many ways to pronounce ``self''.
``Modification'' may mean that an instruction is executed,
manipulated in place, and then executed again;
it may mean that a region of memory is reused,
and holds several instructions over its lifetime;
or, it may mean that the instruction space changes,
even if no part of it is reused.
As for the problem with ``self'', Adam Kao phrased it nicely:

<blockquote>
What I'm trying to say is, what constitutes ``self'' and ``other''
depends on your point of view.
...
Try this simple exercise.
Point a finger at your belly-button.
Poke.
You poked yourself.
Your finger didn't poke <em>itself</em>.
</blockquote>

Some various sensible interpretations include:
(a) instructions that manipulate themselves;
(b) instructions that manipulate other instructions in the same basic
block;
(c) instructions from one source code module manipuate other
instructions in the same module
(d) instructions in one module manipulte instructions
that are created on behalf of that module;
(e) instructions in one address space manipulate other instructions in
the same address space;
(f) instructions in one protection somain mainpulate other
instructions in the same protection domain
(g) instructions being used to solve onen problem manipulate
instructions that are also used to solve the same problem.<p>

The terms <em>code</em> and <em>data</em> are used here in a limited
sense.
``Code'' is used to refer to native machine code that is executable
except that it may live in a data space instead of a code space.
``Data'' is used to refer to all other state, including bits in an
instruction space that are not executable (e.g. are not well-formed
instructions) and things that will be manipulted to become code but
which are not yet executable native machine code.
These definitions are limited because a more general definition of
``code'' defines it relative to some engine of execution.
In particular, ``code'' in a more general sense might include virtual
machine code instructions, source text, etc.
and might also include data values that are used to affect processor
execution in specific ways.<p>

<hr>

<h2>Pardo's RTCG stuff</h2>

<ul>
<li><!WA2><!WA2><!WA2><!WA2><a href="http://www.cs.washington.edu/homes/pardo/papers.d/rtcg-case.html">A Case for Runtime Code Generation</a>.
        Self-Modifying Code considered harmless.
<li><!WA3><!WA3><!WA3><!WA3><a href="http://www.cs.washington.edu/homes/pardo/papers.d/rtcg-icache.html">A Portable Interface for
		On-The-Fly Instruction Space Modification</a>.
        A uniform interface to update the instruction cache ASAP
        when changing the instruction space of a running program.
<li><!WA4><!WA4><!WA4><!WA4><a href="http://www.cs.washington.edu/homes/pardo/papers.d/eval-vso.html">Evaluating Runtime-Compiled
		Value-Specific Optimizations</a>. 
        Dynamically optimizing around the values of variables
        can make even highly-tuned programs run faster.
<li><!WA5><!WA5><!WA5><!WA5><a href="http://www.cs.washington.edu/homes/pardo/papers.d/dylink.html">Faster Dynamic Linking for SPARC
		V8 and System V.4</a>. 
        How to make dynamic linking faster
        and how to do dynamic relinking.
<li><!WA6><!WA6><!WA6><!WA6><a href="http://www.cs.washington.edu/homes/pardo/papers.d/data-break.html">Fast Data Breakpoints</a>.
        Yet <em>another</em> way to implement data breakpoints in a debugger.
	Uses RTCG.
<li><!WA7><!WA7><!WA7><!WA7><a href="http://www.cs.washington.edu/research/compiler/papers.d/shade.html">Shade:
		A Fast Instruction-Set Simulator for Execution Profiling</a>.
        A fast extensible cross-machine simulator that collects all
        sorts of tracing information.
	It's implemented using RTCG.
	See also the
	<!WA8><!WA8><!WA8><!WA8><a href="http://www.cs.washington.edu/homes/pardo/sim.d/index.html">Simulators
		home page</a>.
</ul>

<hr>
<!WA9><!WA9><!WA9><!WA9><a href="http://www.cs.washington.edu/homes/pardo/rtcg.d/mail.d/index.html">Mail
	archive</a>
of postings to the <tt>rtcg</tt> mailing list.
<hr>


<h2>Other RTCG stuff</h2>
<ul>
<li><!WA10><!WA10><!WA10><!WA10><a href="http://www.csl.sony.co.jp/project/Apertos/techpaper.html">Apertos</a>
	reflective operating system using "dynamic compilation" for ???
<li><!WA11><!WA11><!WA11><!WA11><a href="http://ody.zcu.cz/~novy1/">BatOS</a>:
	Everything is viewed as source code that's being edited.
	On invocation, there's a ``freeze'' and compilation.
<li><!WA12><!WA12><!WA12><!WA12><a href="http://www.cs.washington.edu/research/projects/cecil/cecil/www/cecil-home.html">Cecil</a>.
	Cecil code is statically compiled,
	but uses dynamically-compiled
	<!WA13><!WA13><!WA13><!WA13><a href="http://www.cs.ucsb.edu/oocsb/papers/pics.html">PICs</a>.
<li><!WA14><!WA14><!WA14><!WA14><a href="http://www.swiss.ai.mit.edu/~ziggy/ziggy.html">Michael Blair</a>'s
	paper on
	<!WA15><!WA15><!WA15><!WA15><a href="ftp://ftp-swiss.ai.mit.edu/pub/users/ziggy/pac.ps.gz">Improving SCHEME Program Performance
		through Heuristic Redundant Predicate
		Evaluation using PAC Learning Techniques</a>
		(gzip'ped PostScript(tm))
<li><!WA16><!WA16><!WA16><!WA16><a href="http://www.colusa.com">Colusa</a> doesn't say it very loudly,
	but they use a dynamic compiler.
	See <!WA17><!WA17><!WA17><!WA17><a href="http://www.colusa.com/html/omni_www.html">Omniware</a>.
	(Has the link expired?  Here's a
	<!WA18><!WA18><!WA18><!WA18><a href="http://www.cs.washington.edu/homes/pardo/rtcg.d/papers.d/colusa-omniware.ps.gz">local copy</a>
	of the paper.)
<li><!WA19><!WA19><!WA19><!WA19><a href="http://www-csag.cs.uiuc.edu/projects/concert.html">Concert</a>
	used to use (and may again someday use) dynamic compilation in order
	to transform general-purpose ``remote method invocation'' into
	a local procedure call.
	See, in particular,
	<!WA20><!WA20><!WA20><!WA20><a href="http://www-csag.cs.uiuc.edu/papers/concert-overview.ps">UIUC DCS TR R-93-1815</a>
<li><!WA21><!WA21><!WA21><!WA21><a href="http://www.stormking.com/~koth/corewar-faq.html">Core Wars</a>
<li><!WA22><!WA22><!WA22><!WA22><a href="http://amsterdam.lcs.mit.edu/~engler/">Dawson Engler</a>
	is working on general-purpose code generators
	for runtime code generation,
	including DCG
	(<!WA23><!WA23><!WA23><!WA23><a href="http://amsterdam.lcs.mit.edu/PDOS-papers.html/papers/dcg.ps">PostScript(tm) paper</a>)
	and `C
	(<!WA24><!WA24><!WA24><!WA24><a href="http://amsterdam.lcs.mit.edu/PDOS-papers.html/papers/tickc.ps">PostScript(tm) paper</a>)
<li>For supporting
	<!WA25><!WA25><!WA25><!WA25><a href="http://math-www.uio.no/faq/object-faq/part2.html">generics</a>
<li><!WA26><!WA26><!WA26><!WA26><a href="ftp://ftp.netcom.com/pub/hb/hbaker/hakmem/hakmem.html">HAKMEM</a>:
	see
	<ul>
	<li><!WA27><!WA27><!WA27><!WA27><a href="ftp://ftp.netcom.com/pub/hb/hbaker/hakmem/hacks.html#item172">item #172</a>:
	a self-modifying sequence that, in just three instructions
	(including the procedure return) removes a CONS cell from a
	free list, fills it with the CAR and CDR values and,
	if needed, calls the garbage collector.
	(Duplicated <!WA28><!WA28><!WA28><!WA28><a href="http://www.cs.washington.edu/homes/pardo/rtcg.d/papers.d/hacks.html#item172">here</a>)
	<li><!WA29><!WA29><!WA29><!WA29><a href="ftp://ftp.netcom.com/pub/hb/hbaker/hakmem/hacks.html#item179">item #179</a>:
	a dynamically-compiled string matcher that implements the KMP
	searching algorithm, is clearly linear, and which appeared
	at least five years before KMP!
	(Duplicated <!WA30><!WA30><!WA30><!WA30><a href="http://www.cs.washington.edu/homes/pardo/rtcg.d/papers.d/algorithms.html#item179">here</a>)
	</ul>
<li><!WA31><!WA31><!WA31><!WA31><a href="ftp://ftp.cs.washington.edu/homes/pardo/gill.d/gill-00.html">Gill's 1951 EDSAC Debugger</a>:
	used a variety of patching techniques to instrument and
	debug programs.
<li><!WA32><!WA32><!WA32><!WA32><a href="http://java.sun.com/">Java</a>
	uses secure bytecodes to move code from
	machine to machine.
	Someday, those bytecodes may be
	dynamically compiled.
	For example, <!WA33><!WA33><!WA33><!WA33><a href="http://www.softway.com.au/">Softway</a>'s
	<!WA34><!WA34><!WA34><!WA34><a href="http://www.softway.com.au/softway/products/guava/">Guava</a>
	VM.
	For more on moving code across protection boundaries, see
	<!WA35><!WA35><!WA35><!WA35><a href="http://www.w3.org/hypertext/WWW/MobileCode/">Mobile Code</a>.
<li><!WA36><!WA36><!WA36><!WA36><a href="http://www.cs.arizona.edu/sumatra/juice/>Juice</a>
	is a Java-to-C translator.  It's part of "Sumatra", below.
<li><!WA37><!WA37><!WA37><!WA37><a href="http://www.cs.cmu.edu/~koopman">Phil Koopman</a>
	likes RTHWG (Runtime Hardware Generation).
	<! old: http://danville.res.utc.com/Mechatronics/ads/koopman/>
<li><!WA38><!WA38><!WA38><!WA38><a href="http://hopeless.mess.cs.cmu.edu:8001/nitrous/top.html">Lightweight
	languages for interactive graphics</a>
	(<tt>spot@cs.cmu.edu</tt>)
<li><!WA39><!WA39><!WA39><!WA39><a href="http://www.cs.cmu.edu/~mleone/">Mark Leone</a>
	is working on specialized runtime code generators,
	achieving costs as low as 6 cycles per generated instruction
	(see <!WA40><!WA40><!WA40><!WA40><a href="http://www.cs.cmu.edu/afs/cs.cmu.edu/user/mleone/papers/ml-rtcg.ps">here</a>).
<li>MudOS
	(<!WA41><!WA41><!WA41><!WA41><a href="http://hollebeek.hep.upenn.edu:80/~tim/mudos.html">see here</a>)
	uses
	<!WA42><!WA42><!WA42><!WA42><a href="http://hollebeek.hep.upenn.edu/~tim/lpc2c.html">dynamic compilation</a>
	of the LPC extension language,
	in order to minimize the interpretation overhead.
<li><!WA43><!WA43><!WA43><!WA43><a href="http://cdibm.fnal.gov/cern/pawnews-2052.txt">PAW</a>
<li>Perl uses
	``<!WA44><!WA44><!WA44><!WA44><a href="http://mes01.di.uminho.pt/Manuals/Perl/pl-exp-arr.html">runtime compilation</a>''
	of patterns (to vcode), and
	<!WA45><!WA45><!WA45><!WA45><a href="http://www.eecs.nwu.edu/cgi-bin/bbc_man2html?perl(1)">dynamic loading</a>
	(<!WA46><!WA46><!WA46><!WA46><a href="http://zeno.as.arizona.edu:8000/perldocs/perlfunc.html">more</a>)
<li><!WA47><!WA47><!WA47><!WA47><a href="http://cs-tr.cs.berkeley.edu:80/TR/UCB:CSD-94-792">Portable 
	Runtime Code Generation in C</a>.
	(Has the link expired?  Here's a
	<!WA48><!WA48><!WA48><!WA48><a href="http://www.cs.washington.edu/homes/pardo/rtcg.d/papers.d/yarvin-sah-94-792.ps.gz">local copy</a>).
<li><!WA49><!WA49><!WA49><!WA49><a href="http://www.cs.arizona.edu/xkernel/www/people/todd.html">Todd Proebsting</a>
	is working on RTCG, including DCG
	(<!WA50><!WA50><!WA50><!WA50><a href="http://amsterdam.lcs.mit.edu/PDOS-papers.html/papers/dcg.ps">PostScript(tm) paper</a>)
<li>Prolog uses <tt>assert</tt> and <tt>retract</tt> to add and delete
	code from a program.
	If you're using compiled Prolog, then changing the program means
	(a) switching to interpretive execution,
	(b) recompiling the whole program or
	(c) performing
	<!WA51><!WA51><!WA51><!WA51><a href="http://www.complang.tuwien.ac.at/andi/articles.html">incremental analysis</a>
	in order to limit the scope of recompilation.
<li><!WA52><!WA52><!WA52><!WA52><a href="http://foxnet.cs.cmu.edu/afs/cs.cmu.edu/project/fox/mosaic/people/petel/papers/osdi/">Proof-carrying
	code</a> for code motion across protection boundaries.
<li><!WA53><!WA53><!WA53><!WA53><a href="http://www.cs.arizona.edu/xkernel/www/projects/scout.html">Scout</a>
<li><!WA54><!WA54><!WA54><!WA54><a href="http://www.lpac.ac.uk/SEL-HPC/Articles/CompilersArchive.html">SEL-HPC</a>
	has a compilers and interpreters archive that includes
	<!WA55><!WA55><!WA55><!WA55><a href="http://www.lpac.ac.uk/SEL-HPC/Articles/GeneratedHtml/comp.rcg.html">RTCG</a>
	and
	<!WA56><!WA56><!WA56><!WA56><a href="http://www.lpac.ac.uk/SEL-HPC/Articles/GeneratedHtml/comp.link.html">dynamic linking</a>.
<li><!WA57><!WA57><!WA57><!WA57><a href="http://self.smli.com">Self</a>
	(<!WA58><!WA58><!WA58><!WA58><a href="http://www.cs.ucsb.edu/oocsb/self">alternate site</a>)
of compiled C, C++, etc.
	in order to improve embeddability and extensibility.
<li><!WA59><!WA59><!WA59><!WA59><a href="http://www.cs.washington.edu/homes/pardo/sim.d/index.html">Simulators</a>often use dynamic-cross compilation and other such techniques.
<li><!WA60><!WA60><!WA60><!WA60><a href="http://www.cs.washington.edu/research/projects/spin/www/">SPIN</a>,
	supporting VSO and dynamic linking of kernel extensions.
	Including
	<!WA61><!WA61><!WA61><!WA61><a href="http://www.cs.washington.edu/research/projects/spin/www/ARPA/blue_book-overview.html">here</a>
	and
	<!WA62><!WA62><!WA62><!WA62><a href="http://www.cs.washington.edu/research/projects/spin/www/ARPA/blue_book-accomplishments.html">here</a>
<li><!WA63><!WA63><!WA63><!WA63><a href="http://www.cs.arizona.edu/sumatra/">Sumatra</a>
	Is a project to explore issues about efficient execution of mobile code.
<li><!WA64><!WA64><!WA64><!WA64><a href="http://www.cis.upenn.edu/~jms/SoftSwitch.html">SwitchWare</a>:
	Making the network interface programmable.
	(There is also a
	<!WA65><!WA65><!WA65><!WA65><a href="http://www.cis.upenn.edu/~jms/white-paper.ps">PostScript paper</a>.)
<li><!WA66><!WA66><!WA66><!WA66><a href="http://www.cse.ogi.edu/DISC/projects/synthetix">Synthetix</a>,
	a follow-on to Synthesis.
<li><!WA67><!WA67><!WA67><!WA67><a href="http://www.tandem.com/source/product/html/DALSVRPD.html">Tandem
	databases</a>.
<li><!WA68><!WA68><!WA68><!WA68><a href="http://www.cs.washington.edu:80/research/compiler/rtcg.html">UW RTCG</a>
<li><!WA69><!WA69><!WA69><!WA69><a href="http://www.ai.mit.edu/projects/transit/transit_home_page.html">Transit</a>
	suggests ``Computational Quasistatics'' --
	profile feedback to an online optimizer.
	<ul>
	<li><!WA70><!WA70><!WA70><!WA70><a href="http://www.ai.mit.edu/projects/transit/suif_usage.html">Quasistatic if-then-else</a>
	<li><!WA71><!WA71><!WA71><!WA71><a href="http://www.ai.mit.edu/projects/transit/smart_compiler.html">Smart Compilers</a> references
	<li><!WA72><!WA72><!WA72><!WA72><a href="http://www.ai.mit.edu/projects/transit/rc_home_page.html">Reinventing computing?</a>
	</ul>
<li>The
	<!WA73><!WA73><!WA73><!WA73><a href="http://www.complang.tuwien.ac.at/andi/">Vienna
		Abstract Machine</a>
	uses incremental compilation.
</ul>

<h2>Dynamic Linking</h2>

<ul>
<li><!WA74><!WA74><!WA74><!WA74><a href="gopher://ftp.std.com:70/00/obi/book/USENIX/index.cat">Caching to
	improve the performance</a> of dynamic linking
	(see also
	<!WA75><!WA75><!WA75><!WA75><a href="gopher://ftp.std.com:70/00/obi/book/USENIX/index">here</a>
<li><!WA76><!WA76><!WA76><!WA76><a href="http://www-dsg.stanford.edu/papers/cachekernel/main.html">Cache Kernel</a>
	uses dynamically-loaded application-specific kernel modules.
<li><!WA77><!WA77><!WA77><!WA77><a href="http://www.netmanage.com/netmanage/products/cham.html">Chameleon</a>
	is a TCP/IP layer for Windows, implemented as a
	<li><!WA78><!WA78><!WA78><!WA78><a href="http://www.netmanage.com/netmanage/nm6.html">DLL</a>.
	Likewise,
	<!WA79><!WA79><!WA79><!WA79><a href="http://www.vitinc.com/home4.html">here</a>.
<li>CLIPS
	<!WA80><!WA80><!WA80><!WA80><a href="ftp://hubble.jsc.nasa.gov/pub/clips/clips-faq">uses dynamic linking</a>
<li><!WA81><!WA81><!WA81><!WA81><a href="ftp://listserv.arizona.edu/pub/listserv/toolb-l/toolb-l.log9401">Compression DLL</a>
<li><!WA82><!WA82><!WA82><!WA82><a href="http://legend.gwydion.cs.cmu.edu:8001/dylan/book/contents.html">Dylan</a>
	<!WA83><!WA83><!WA83><!WA83><a href="http://legend.gwydion.cs.cmu.edu:8001/dylan/book/ch1.html">uses dynamic linking</a>
<li><!WA84><!WA84><!WA84><!WA84><a href="http://siva.cshl.org/cgi-bin/lsmbyid?00313">dld</a> is a
	dynamic linker provided with Linux.
<li>Fast turnaround edit-compile-debug with incremental compilation
	and dynamic linking.
	<ul>
	<li><!WA85><!WA85><!WA85><!WA85><a href="http://www.franz.com/acl-win.html">Allegro Common Lisp</a>
	<li><!WA86><!WA86><!WA86><!WA86><a href="http://www-lp.doc.ic.ac.uk/Files/clp.faq.implementations">Prolog</a>
		(SNI Prolog Version 3, in particular)
	<li><!WA87><!WA87><!WA87><!WA87><a href="http://mosaic.reasoning.com/press-release-94-05-16.html">Software Refinery</a>
	</ul>
<li><!WA88><!WA88><!WA88><!WA88><a href="http://www.cilabs.org/pub/cilabs/general/CILabs_Bckgrdr_9409/CILabs_Bckgrdr_9409.html">Interoperating
documents</a>
	use dynamic linking
	(see also <!WA89><!WA89><!WA89><!WA89><a href="http://www.novell.com/">under here</a>).
<li><!WA90><!WA90><!WA90><!WA90><a href="ftp://sunsite.unc.edu/pub/Linux/docs/HOWTO/ELF-HOWTO">ELF</a>
	vs. <tt>a.out</tt> dynamic linking
<li>GNU's HURD uses
	<!WA91><!WA91><!WA91><!WA91><a href="http://www.uruk.org/hurd-proj/hurd-exec.html">dynamic linking</a>
<li><!WA92><!WA92><!WA92><!WA92><a href="ftp://archive.cis.ohio-state.edu/pub/hcibib/ECHT90.bib">Hypertext
	using dynamic linking</a>
<li><!WA93><!WA93><!WA93><!WA93><a href="http://www.kaleida.com/">Kaleida</a>'s <em>ScriptX</em>
	uses dynamic linking.
	<quotation>
	I'm implementing a dynamic linker for a programming language
	similar to Dylan.  (The language is ScriptX, see
	<!WA94><!WA94><!WA94><!WA94><a href="http://www.kaleida.com/">http://www.kaleida.com/</a>
	for more information about it.)  It uses a module system that
	is almost identical to Dylan's module system.
	A module can export variables to publish interfaces,
	and it can use other modules to gain access to their published
	interfaces.  Modules can be saved from a compilation
	environment into a persistent store with the variables defined
	within them, and later loaded into a runtime environment.
	</quotation>
	<tt>eb@kaleida.com (Eric Benson)</tt> in
	<tt>comp.compilers</tt> article 28 July 1995.
<li><!WA95><!WA95><!WA95><!WA95><a href="gopher://ftp.std.com:70/00/obi/book/USENIX/index.cat">Language extensions</a>
	use dynamic linking
	(see also
	<!WA96><!WA96><!WA96><!WA96><a href="gopher://ftp.std.com:70/00/obi/book/USENIX/index">here</a>)
<li>Microsoft Windows has a dynamic linker interface that
	<!WA97><!WA97><!WA97><!WA97><a href="gopher://ds1.internic.net:70/00/internet-drafts/draft-ietf-cat-wingss-00.txt">requires the use of FAR pointers</a>
<li><!WA98><!WA98><!WA98><!WA98><a href="http://www.mit.edu:8001/afs/net/user/srz/www/multics.html">Multics</a>,
	<!WA99><!WA99><!WA99><!WA99><a href="http://www.best.com/~thvv/multics.html">Multics</a>,
<li><!WA100><!WA100><!WA100><!WA100><a
href="http://www.austin.ibm.com/developer/aix/library/aixpert/june94/aixpert_june94_closeup.html">OpenDoc</a>
	and
	<!WA101><!WA101><!WA101><!WA101><a href="http://www.cilabs.org/pub/cilabs/general/CILabs_Bckgrdr_9409/CILabs_Bckgrdr_9409.html">details</a>
<li>OS/2 uses
	<!WA102><!WA102><!WA102><!WA102><a href="gopher://index.almaden.ibm.com/0os2dsn/dsn4c.asc">dynamic linking</a>
<li>Perl also uses
	<!WA103><!WA103><!WA103><!WA103><a href="ftp://rtfm.mit.edu/pub/usenet-by-hierarchy/comp/lang/perl/comp.lang.perl_FAQ_3_5_-_Programming_Aids">Dynamic Linking</a>
<li>Ptolemy
	<!WA104><!WA104><!WA104><!WA104><a href="http://ptolemy.eecs.berkeley.edu/reports/94/9">uses dynamic linking</a>.
<li>The Rochelle Caller ID adapter
	<!WA105><!WA105><!WA105><!WA105><a href="http://www.tpoint.net/rochelle/toolkits.html">uses dynamic linking</a>
<li>Rochester CS uses dynamic linking, e.g.
	<!WA106><!WA106><!WA106><!WA106><a href="http://www.cs.rochester.edu/trs/systems-trs.html">here</a>
	and
	<!WA107><!WA107><!WA107><!WA107><a href="http://www.rdt.monash.edu.au/cgi-bin/techreports/ROCH">here</a>
<li><!WA108><!WA108><!WA108><!WA108><a href="http://tuvalu.cs.flinders.edu.au/./People/Bradley_Schmerl/home.html">Bradley Schmerl</a>
	is interested in dynamic linking.
<li>TCL
	<!WA109><!WA109><!WA109><!WA109><a href="http://theory.doc.ic.ac.uk/tcl/tclFAQ/part5/faq.html">seems to use dynamic linking</a>
<li><!WA110><!WA110><!WA110><!WA110><a href="http://www.vitinc.com/home4.html">Winsock</a> uses
	dynamic lnking.
	So does
	<!WA111><!WA111><!WA111><!WA111><a href="http://www.twg.com/newsletters/link-nov93.html">PathWay Access</a>
	for OS/2.
<li>W3A uses
	<!WA112><!WA112><!WA112><!WA112><a href="http://grid.let.rug.nl/~bert/W3A/W3A.html">dynamic linking</a>
	for extensible WWW browsing,
	as does
	<!WA113><!WA113><!WA113><!WA113><a href="ftp://archive.cis.ohio-state.edu/pub/hcibib/HYPER91.bib">CYBERMAP</a>.
<li>The book
	<!WA114><!WA114><!WA114><!WA114><a href="http://www.cs.cmu.edu/afs/cs.cmu.edu/project/ai-repository/ai/html/cltl/dp_catalog.html">OBJECT
	ORIENTED PROGRAMMING UNDER WINDOWS A PRACTICAL HANDBOOK</a>
	by Stephen Morris
	seems to talk about dynamic linking.
<li><!WA115><!WA115><!WA115><!WA115><a href="http://www.town.hall.org/Archives/patent/data/05297/05297249">This
		patent</a>
	uses it.
<li>Some OS's provide dynamic linking as a system service
	<ul>
	<li>	Linux
	<li>	Microsoft Windows
	<li>	OSF/1
	<li>	SunOS
	</ul>
<li>Some applications support multiple extension languages via dynamic
	linking.
	In part, this falls under the heading of using dynamic linking
	because ``it's got a clean interface''.
	<ul>
	<li><!WA116><!WA116><!WA116><!WA116><a href="http://web.cs.ualberta.ca/~wade/Auto/HyperTcl/Tcl_extensions.html">Tcl</a>
	</ul>
<li>Some applications seem to use dynamic linking just because it's
	got a clean interface and/or minimizes the size of the final
	executable.
	Some of the above plus
	<ul>
	<li><!WA117><!WA117><!WA117><!WA117><a href="http://www.teknowledge.com/M4/proddesc.html">M.4
		expert system</a>;
	<li><!WA118><!WA118><!WA118><!WA118><a href="http://www.nag.co.uk/0h/new/clibdll">Numerical C</a>
		Dynamic Link Library,
	<li><!WA119><!WA119><!WA119><!WA119><a href="http://www.qrz.com/qrz_cd.html">Ham radio database</a>,
	<li><!WA120><!WA120><!WA120><!WA120><a href="http://www.fse.com/elite.html">DynaComm/Elite</a>
		3270 emulation/connection library
	<li><!WA121><!WA121><!WA121><!WA121><a href="ftp://ftp.digital.com/pub/Digital/info/SPD/43-54-01.txt">DEC telephone controller</a>
	</ul>
<li>Some libraries are provided as dynamically-linked libraries
	so that system A can export libraries to a generic application B
	and B can link in the libraries to operate on the data
	provided by A.
	<ul>
	<li><!WA122><!WA122><!WA122><!WA122><a href="http://www.bion.kth.se/tests/xor/report/report.html">XOR</a>
		External Object Representation
	<li>The
		<!WA123><!WA123><!WA123><!WA123><a href="http://www.ep.se/cool/">Cool Edit system</a>,
		which uses
		<!WA124><!WA124><!WA124><!WA124><a href="http://www.ep.se/cool/details/filtapi.htm">File filters</a>
		for
		<!WA125><!WA125><!WA125><!WA125><a href="http://www.ep.se/cool/default.htm">audio editing</a>
	<li><!WA126><!WA126><!WA126><!WA126><a href="http://bristol.com/Ptimes/nov94.html">Wind/U</a>
		for providing data exchange between programs on Unix platforms,
		as in Microsft Windows platforms.
	</ul>
<li><!WA127><!WA127><!WA127><!WA127><a href="http://www.math.uio.no/faq/visual-basic-faq/general-info.html">For
		interpreting</a>
	visual basic programs.
<li><!WA128><!WA128><!WA128><!WA128><a href="http://www.austin.ibm.com/software/g2213651.html">IBM SOM</a>
	allowing inter-language object calls.
	The toolkit for creating class libraries and instances.
	Uses DLL to allow new releases of system libraries w/o
	recompiling applications.
<li><!WA129><!WA129><!WA129><!WA129><a href="http://www.srdc.metu.edu.tr/mood/index.html">METU</a>
	uses a
	"<!WA130><!WA130><!WA130><!WA130><a href="http://www.srdc.metu.edu.tr/mood/publications.html">dynamic function linker</a>",
	for an O-O database.
</ul>

<h2>Not RTCG but related</h2>
<ul>
<li><!WA131><!WA131><!WA131><!WA131><a href="http://www.cs.cmu.edu/afs/cs.cmu.edu/project/sfi/www/top.html">Software
		fault isolation</a>:
	disallows RTCG, but could have easily been extended to use
	it provided it was performed using a well-structured interface
	such as
	``<!WA132><!WA132><!WA132><!WA132><a href="http://www.cs.washington.edu/homes/pardo/papers.d/rtcg-icache.html">A Portable Interface for
		On-The-Fly Instruction Space Modification</a>''.
<li><!WA133><!WA133><!WA133><!WA133><a href="http://www.cs.rulimburg.nl:80/~vreeswyk/research.htm">Self-modifying
		communication protocols</a>
	for multi-agent communication systems.
	Contact:
	<!WA134><!WA134><!WA134><!WA134><a href="http://www.cs.rulimburg.nl:80/~vreeswyk/">Gerard A. W.
		Vreeswijk</a>
	(`<tt>vreeswyk@cs.rulimburg.nl</tt>').
<li><!WA135><!WA135><!WA135><!WA135><a href="http://www.cs.buffalo.edu/~boyd/perl.html">Self-reproducing Perl</a>
	courtesey
	<!WA136><!WA136><!WA136><!WA136><a href="http://www.cs.buffalo.edu/~boyd/">Dan Boyd</a>
	(<tt>boyd@cs.buffalo.edu</tt>).
</ul>

<hr>

<address>
<!WA137><!WA137><!WA137><!WA137><a href="http://www.cs.washington.edu/homes/pardo/home.html"><tt>pardo@cs.washington.edu</tt></a>
</address>

</body>
</html>
